COMMENT ⊗   VALID 00002 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002
C00024 ENDMK
C⊗;

 Experiments indicate that SAME-SIZE is not affected by reordering 
elements of its structural arguments.
       So any canonical arguments can be Bags and Sets.
(STRUCTURE-E-DEFN-NEC compiling)
(STRUCTURE-E-DEFN-NEC (BA1 BA2 BA3 BA4) NIL)

 Experiments indicate that SAME-SIZE is affected by the presence of 
multiple elements in its structural arguments.
       So any canonical arguments can be Bags and Lists.

 SAME-SIZE doesn't look at the specific elements in OBJECT,  like 
OBJ-EQUAL does,  so AM can replace them all by a single distinguished 
element,  say T.

Succeeded! 

 Some conjectures that AM considers believable:

 OBJ-EQUAL,  restricted to canonical BAG-STRUC's,  is indistinguishable 
from SAME-SIZE.

 There is a powerful analogy between

SAME-SIZE........................OBJ-EQUAL
BAG-STRUC........................CANONICAL-BAG-STRUC
operators on and into............those operators restricted to
      BAG-STRUC..................      CANONICAL-BAG-STRUC
statements involving these.......statements involving these


 Do-thresh raised from 431 to 457.

 This Cand used 17.297 cpu seconds.




 The top 3 Cands are:
    1: Fill in some examples of Canonical-bag-struc
    2: Restrict the following:  Same-size Canonical-bag-struc Domain 
    3: Coalesce Map-replace2-set-struc&set-struc-proj2

 I choose first Cand.       OK?   yes.

       The reason is: (Any example of CANONICAL-BAG-STRUC is a canonical
example of BAG-STRUC)


      Beginning 113rd cycle.

(CANONICAL-BAG-STRUC-E-DEFN compiling)
(CANONICAL-BAG-STRUC-E-DEFN (BA1 BA2 BA3) (TK2))


 AM will now try to produce examples of CANONICAL-BAG-STRUC by running 
the following operations:
       (CANONIZE-SAME-SIZE&OBJ-EQUAL).

(CANONIZE-SAME-SIZE&OBJ-EQUAL-E-ALGS compiling)
(CANONIZE-SAME-SIZE&OBJ-EQUAL-E-ALGS (BA1 BA2 BA3 BA4 BA5) NIL)
 Won't try to create a restricted interesting version of 
CANONICAL-BAG-STRUC.

 Filled in examples of CANONICAL-BAG-STRUC.
       0 examples existed originally on CANONICAL-BAG-STRUC.
       211 potential new entries were just proposed.

 Eliminating duplicates,  the newly constructed examples are:
      (BAG)
      (BAG T T)
      (BAG T T T)
      (BAG T)
      (BAG T T T T T)
      (BAG T T T T)
      (BAG T T T T T T T T T T T T T T T T T T T T T T T T T T T T
T T)
 After eliminating duplicate and already-known entries,  AM finds that.
 only 7 new,  distinct examples of CANONICAL-BAG-STRUC had to be added.



 Do-thresh raised from 457 to 478.

 This Cand used 35.918 cpu seconds.




 The top 3 Cands are:
    1: Restrict the following:  Same-size Canonical-bag-struc Domain 
    2: Coalesce Map-replace2-set-struc&set-struc-proj2
    3: Restrict the following:  Obj-equal Canonical-object Domain 

 I choose first Cand.       OK?   yes.

       The reason is: (SAME-SIZE was one of the predicates which defined
the new concept CANONICAL-BAG-STRUC ,  so it is worth considering
the restriction of SAME-SIZE to that subset of BAG-STRUC 's)


      Beginning 114th cycle.


GC: 8
14725, 14725 FREE WORDS

Succeeded! 

 Do-thresh raised from 478 to 495.

 This Cand used 3.311 cpu seconds.




 The top 3 Cands are:
    1: Coalesce Map-replace2-set-struc&set-struc-proj2
    2: Restrict the following:  Obj-equal Canonical-object Domain 
    3: Check all examples of Canonical-object

 I choose first Cand.       OK?  π

?: N

 Rename which existing concept? CANONICAL-BAG-STRUC

 What is its new name? NUMBER

 Done.


 yes.

       The reason is: (MAP-REPLACE2-SET-STRUC&SET-STRUC-PROJ2 is 
interesting ,  an Operation with at least two arguments ,  22 known
examples ,  and either I have never tried to coalesce it or else I
am desparate)


      Beginning 115th cycle.


 AM will merge the 2 nd and the 1 st arguments of 
MAP-REPLACE2-SET-STRUC&SET-STRUC-PROJ2; that is,  SET-STRUC and 
SET-STRUC.
πinterrupted before DREMOVE

(DREMOVE broken)
:(CAR CONCEPTS)
COA-MAP-REPLACE2-SET-STRUC&SET-STRUC-PROJ2
:
(CADR CONCEPTS)
NUMBER
:
(CADDR CONCEPTS)
RESTRICT-SAME-SIZE&CANONICAL-BAG-STRUC
:
(CADDDR CONCEPTS)
CANONICAL-BAG-STRUC
:
(CADDDDR CONCEPTS)
CANONIZE-SAME-SIZE&OBJ-EQUAL
:
OK
DREMOVE

 Do-thresh raised πfrom

?:  (W, I, E, M, N, ?, Q) N

 Rename which existing concept? CANONIZE-SAME-SIZE&OBJ-EQUAL

 What is its new name? SIZE

 Done.


 495 to 509.

 This Cand used 2.702 cpu seconds.




 The top 3 Cands are:
    1: Check all examples of Number
    2: Restrict the following:  Obj-equal Canonical-object Domain 
    3: Check all examples of Canonical-object

 I choose first Cand.       OK?   yes.

       The 2 reasons are:
      (Interestingness of NUMBER has changed recently)
      (Some new ,  unchecked examples of NUMBER have recently been
added)


      Beginning 116th cycle.

 Checked examples of NUMBER and all entries were confirmed

 This Cand used 1.909 cpu seconds.




 The top 3 Cands are:
    1: Fill in some conjectures involving the concept of Number
    2: Restrict the following:  Obj-equal Canonical-object Domain 
    3: Check all examples of Canonical-object

 I choose first Cand.       OK?   yes.

       The reason is: (Examples of NUMBER remain after checking , 
to compare against other concepts)


      Beginning 117th cycle.

(INT-NON-EMPTY-STRUC-E-DEFN compiling)
(INT-NON-EMPTY-STRUC-E-DEFN (BA1 BA2 BA3) (BA4))
(SPEC-INT-NON-EMPTY-STRUC-E-DEFN compiling)
(SPEC-INT-NON-EMPTY-STRUC-E-DEFNA0007 compiling)
(SPEC-INT-NON-EMPTY-STRUC-E-DEFNA0007 (P) (BA1))
(SPEC-INT-NON-EMPTY-STRUC-E-DEFN (BA1 BA2 BA3) (BA4))

Failed.  Tried to fill in new conjectures involving the concept of 
NUMBER.

 This Cand used 15.414 cpu seconds.




 The top 3 Cands are:
    1: Restrict the following:  Obj-equal Canonical-object Domain 
    2: Check all examples of Canonical-object
    3: Check all things which just barely miss being examples of Number

 I choose first Cand.       OK?   yes.

       The reason is: (OBJ-EQUAL operates on the space OBJECT ,  for
which we now have a canonical representation)


      Beginning 118th cycle.


Succeeded! 

 Do-thresh raised from 507 to 510.

 This Cand used 2.676 cpu seconds.




 The top 3 Cands are:
    1: Check all examples of Canonical-object
    2: Check all things which just barely miss being examples of Number
    3: Coalesce Map-join

 I choose first Cand.       OK?   yes.

       The reason is: (Some new ,  unchecked examples of 
CANONICAL-OBJECT have recently been added)


      Beginning 119th cycle.


 CANONICAL-OBJECT has 7 examples which occupy 11 list cells,  but is not
 interesting enough to warrant taking up that much space; so about 2 
will be selected at random and forgotten.
 Checked examples of CANONICAL-OBJECT.
       12 entries were there initially.
       10 were never confirmed or rejected.
       2 had to be completely discarded.
       5 entries are present now.


GC: 8
14582, 14582 FREE WORDS

 Do-thresh raised from 510 to 510.

 This Cand used 16. 626 cpu Runningseconds.

 at 6312  Load av. =  1.36, used 0:56:22.5 in 2:14:52

 No Cand on CANDS is good enuf.
 Do-thresh reduced from 510 to 340
 Must find new candidates and merge them into CANDS.



 The top 3 Cands are:
    1: Fill in some examples of Size
    2: Fill in some examples of Size
    3: Fill in some examples of Canonize-genl-obj-equal-1&obj-equal

 I choose first Cand.       OK?   yes.

       The reason is: (We have no examples for 
CANONIZE-SAME-SIZE&OBJ-EQUAL yet)


      Beginning 120th cycle.


 Record of attempts to find examples:
 An ex ( sought) is: (BAG T)++++++++++++++++++++++++++

 Found 26 examples ( and 0 non-exs),  in 1.016 secs.
 A nice ratio of exs/non-exs was encountered for 
CANONIZE-SAME-SIZE&OBJ-EQUAL
 Won't try to create a restricted interesting version of 
CANONIZE-SAME-SIZE&OBJ-EQUAL.

 Filled in examples of CANONIZE-SAME-SIZE&OBJ-EQUAL.
       0 examples existed originally on CANONIZE-SAME-SIZE&OBJ-EQUAL.
       26 potential new entries were just proposed.

 Eliminating duplicates,  the newly constructed examples are:
      ((BAG T) (BAG T))
      ((BAG A A B) (BAG T T T))
      ((BAG T T T T) (BAG T T T T))
      ((BAG R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5
R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1
R6-2 R6-3 R6-4 R6-5 R6-6) (BAG T T T T T T T T T T T T T T T T T T
T T T T T T T T T T T T))
      ((BAG T T T T T T T T T T T T T T T T T T T T T T T T T T T
T T T) (BAG T T T T T T T T T T T T T T T T T T T T T T T T T T T
T T T))
      ((BAG) (BAG))
      ((BAG A B (BAG B) (CLASS)) (BAG T T T T))
      ((BAG DON ED) (BAG T T))
      ((BAG T T) (BAG T T))
      ((BAG A B) (BAG T T))
      ((BAG 0 D F I M) (BAG T T T T T))
      ((BAG T T T T T) (BAG T T T T T))
      ((BAG A) (BAG T))
 After eliminating duplicate and already-known entries,  AM finds that.
 only 13 new,  distinct examples of CANONIZE-SAME-SIZE&OBJ-EQUAL had to 
be added.



 Do-thresh raised from 340 to 414.

 This Cand used 9.2 cpu seconds.




 The top 3 Cands are:
    1: Fill in some examples of Size
    2: Check all examples of Size
    3: Fill in some examples of Canonize-genl-obj-equal-1&obj-equal

 I choose first Cand.       OK?   yes.

       The reason is: (We have no examples for SIZE yet)


      Beginning 121st cycle.


 Record of attempts to find examples:
 An ex ( sought) is: (BAG T T)++++++++++++++++++++++++++

 Found 26 examples ( and 0 non-exs),  in .996 secs.
 A nice ratio of exs/non-exs was encountered for SIZE
 Won't try to create a restricted interesting version of SIZE.

 Filled in examples of SIZE.
       13 examples existed originally on SIZE.
       26 potential new entries were just proposed.

 Eliminating duplicates,  the newly constructed examples are:
      ((BAG T T) (BAG T T))
      ((BAG T T T T T) (BAG T T T T T))
      ((BAG B) (BAG T))
      ((BAG A A) (BAG T T))
      ((BAG T T T) (BAG T T T))
      ((BAG T T T T) (BAG T T T T))
      ((BAG A B) (BAG T T))
      ((BAG R2-1 R2-2 R2-3 R2-4 R2-5 R2-6 R3-1 R3-2 R3-3 R3-4 R3-5
R3-6 R4-1 R4-2 R4-3 R4-4 R4-5 R4-6 R5-1 R5-2 R5-3 R5-4 R5-5 R5-6 R6-1
R6-2 R6-3 R6-4 R6-5 R6-6) (BAG T T T T T T T T T T T T T T T T T T
T T T T T T T T T T T T))
      ((BAG A A B) (BAG T T T))
      ((BAG 0 D F I M) (BAG T T T T T))
      ((BAG A) (BAG T))
      ((BAG T T T T T T T T T T T T T T T T T T T T T T T T T T T
T T T) (BAG T T T T T T T T T T T T T T T T T T T T T T T T T T T
T T T))
      ((BAG DON ED) (BAG T T))
      ((BAG A B (BAG B) (CLASS)) (BAG T T T T))
 After eliminating duplicate and already-known entries,  AM finds that.
 only 3 new,  distinct examples of SIZE had to be added.



 Do-thresh raised from 414 to 473.

 This Cand used 8.473 cpu seconds.




 The top 3 Cands are:
    1: Check all examples of Size
    2: Check all examples of Size
    3: Fill in some examples of Canonize-genl-obj-equal-1&obj-equal

 I choose first Cand.       OK?   yes.

       The reason is: (Some new ,  unchecked examples of 
CANONIZE-SAME-SIZE&OBJ-EQUAL have recently been added)


      Beginning 122nd cycle.

(CANONIZE-SAME-SIZE&OBJ-EQUAL-E-DEFN compiling)
(CANONIZE-SAME-SIZE&OBJ-EQUAL-E-DEFN (BA1 BA2 BA3) NIL)
 Checked examples of CANONIZE-SAME-SIZE&OBJ-EQUAL and all entries were 
confirmed

 This Cand used 4.348 cpu seconds.




 The top 3 Cands are:
    1: Fill in some conjectures involving the concept of Size
    2: Check all examples of Size
    3: Fill in some examples of Canonize-genl-obj-equal-1&obj-equal

 I choose first Cand.       OK?   yes.

       The reason is: (Examples of CANONIZE-SAME-SIZE&OBJ-EQUAL remain
after checking ,  to compare against other concepts)


      Beginning 123rd cycle.


GC: 8
 Running at 23077  Load av. =  1.69, used 0:57:51.4 in 2:17:17
15397, 15397 FREE WORDS
 CANONIZE-SAME-SIZE&OBJ-EQUAL apparently is a specialization of SIZE.
(CANONIZE-GENL-OBJ-EQUAL-1&OBJ-EQUAL-E-DEFN compiling)
(CANONIZE-GENL-OBJ-EQUAL-1&OBJ-EQUAL-E-DEFN (BA1 BA2 BA3) NIL)
 Running at 434223  Load av. =  1.37, used 0:59:29.4 in 2:18:59
 Running at 434223  Load av. =  1.31, used 1:01:09.6 in 2:20:36
π Running at 434223  Load av. =  1.25, used 1:02:35.5 in 2:21:58
 Running at 434223  Load av. =  1.40, used 1:03:39.4 in 2:23:02
π
BREAK

(BLIPEVAL broken)
:BT
BLIPEVAL
HELPDLBLOCK
ERRORX
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FRIPPLE-S
FR